diff --git a/user_guide/general/creating_libraries.html b/user_guide/general/creating_libraries.html
index 6a4773b..d32dda9 100644
--- a/user_guide/general/creating_libraries.html
+++ b/user_guide/general/creating_libraries.html
@@ -179,12 +179,13 @@
 
 <p>First, assign the CodeIgniter object to a variable:</p>
 
-<code>$CI =& get_instance();</code>
+<code>$CI =&amp; get_instance();</code>
 
 <p>Once you've assigned the object to a variable, you'll use that variable <em>instead</em> of <kbd>$this</kbd>:</p>
 
 <code>
-$CI =& get_instance();<br /><br />
+$CI =&amp; get_instance();<br />
+<br />
 $CI->load->helper('url');<br />
 $CI->load->library('session');<br />
 $CI->config->item('base_url');<br />
@@ -193,8 +194,9 @@
 
 <p class="important"><strong>Note:</strong> You'll notice that the above get_instance() function is being passed by reference:
 <br /><br />
-<var>$CI =& get_instance();</var>
-<br /><br />
+<var>$CI =&amp; get_instance();</var>
+<br />
+<br />
 <kbd>This is very important.</kbd> Assigning by reference allows you to use the original CodeIgniter object rather than creating a copy of it.
 <br /><br />
 <kbd>Also, please note:</kbd> If you are running PHP 4 it's usually best to avoid calling <dfn>get_instance()</dfn>
diff --git a/user_guide/general/hooks.html b/user_guide/general/hooks.html
index e24c48a..14e28d4 100644
--- a/user_guide/general/hooks.html
+++ b/user_guide/general/hooks.html
@@ -127,7 +127,7 @@
 
 <h2>Hook Points</h2>
 
-The following is a list of available hook points.</p>
+<p>The following is a list of available hook points.</p>
 
 <ul>
 
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index 87a01d6..c506874 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -79,19 +79,9 @@
 
 <h2>Setting Benchmark Points</h2>
 
-<p>In order for the Profiler to compile and display your benchmark data you must name your mark points using specific syntax.
+<p>In order for the Profiler to compile and display your benchmark data you must name your mark points using specific syntax.</p>
 
-Please read the information on setting Benchmark points in <a href="../libraries/benchmark.html">Benchmark Class</a> page.</p>
-
-
-
-</code>
-
-
-
-
-
-
+<p>Please read the information on setting Benchmark points in <a href="../libraries/benchmark.html">Benchmark Class</a> page.</p>
 
 
 
diff --git a/user_guide/general/security.html b/user_guide/general/security.html
index 5fa6cf3..271fea8 100644
--- a/user_guide/general/security.html
+++ b/user_guide/general/security.html
@@ -99,13 +99,12 @@
 XML-RPC data, or even data from the SERVER array, you are encouraged to practice this three step approach:</p>
 
 <ol>
-
 <li>Filter the data as if it were tainted.</li>
 <li>Validate the data to ensure it conforms to the correct  type, length, size, etc. (sometimes this step can replace step one)</li>
 <li>Escape the data before submitting it into your database.</li>
 </ol>
 
-CodeIgniter provides the following functions to assist in this process:</p>
+<p>CodeIgniter provides the following functions to assist in this process:</p>
 
 <ul>
 
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index f839304..823610f 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -74,7 +74,7 @@
 <ol>
 <li>The first segment represents the controller <strong>class</strong> that should be invoked.</li>
 <li>The second segment represents the class <strong>function</strong>, or method, that should be called.</li>
-<li>The third, and any additional segments, represent the ID and any variables that will be passed to the controller.</p>
+<li>The third, and any additional segments, represent the ID and any variables that will be passed to the controller.</li>
 </ol>
 
 <p>The <a href="../libraries/uri.html">URI Class</a> and the <a href="../helpers/url_helper.html">URL Helper</a>
@@ -116,7 +116,7 @@
 
 <p>In some cases you might prefer to use query strings URLs:</p>
 
-<code>index.php?c=products&m=view&id=345</code>
+<code>index.php?c=products&amp;m=view&amp;id=345</code>
 
 <p>CodeIgniter optionally supports this capability, which can be enabled in your <dfn>application/config.php</dfn> file. If you
 open your config file you'll see these items:</p>
@@ -128,7 +128,7 @@
 <p>If you change "enable_query_strings" to TRUE this feature will become active.  Your controllers and functions will then
 be accessible using the "trigger" words you've set to invoke your controllers and methods:</p>
 
-<code>index.php?c=controller&m=method</code>
+<code>index.php?c=controller&amp;m=method</code>
 
 <p class="important"><strong>Please note:</strong> If you are using query strings you will have to build your own URLs, rather than utilizing
 the URL helpers (and other helpers that generate URLs, like some of the form helpers) as these are designed to work with
